package gorouting

import (
	"fmt"
	"runtime"
	"sync"
	"time"
)

//package main
//
//import (
//"context"
//"fmt"
//"sync"
//"time"
//)

// Pool 简洁协程池结构体
type Pool struct {
	maxWorkers int            // 最大工作协程数
	taskQueue  chan func()    // 任务队列
	stopChan   chan struct{}  // 关闭信号
	wg         sync.WaitGroup // 等待所有任务完成
}

// NewPool 创建协程池
func NewPool(maxWorkers, queueSize int) *Pool {
	return &Pool{
		maxWorkers: maxWorkers,
		taskQueue:  make(chan func(), queueSize),
		stopChan:   make(chan struct{}),
	}
}

// Start 启动协程池
func (p *Pool) Start() {
	// 启动固定数量的工作协程
	for i := 0; i < p.maxWorkers; i++ {
		p.wg.Add(1)
		go p.worker()
	}
}

// worker 工作协程核心逻辑
func (p *Pool) worker() {
	defer p.wg.Done()
	for {
		select {
		case task := <-p.taskQueue: // 执行任务
			task()
		case <-p.stopChan: // 接收停止信号
			return
		}
	}
}

// Submit 提交任务
func (p *Pool) Submit(task func()) {

	select {
	case p.taskQueue <- task: // 任务入队
	case <-p.stopChan: // 池已关闭
		fmt.Println("Pool is closed, task rejected")
	}
}

// Shutdown 优雅关闭
func (p *Pool) Shutdown() {
	close(p.stopChan)  // 发送关闭信号
	p.wg.Wait()        // 等待所有任务完成
	close(p.taskQueue) // 清空任务队列
}

// 示例用法
func main() {
	pool := NewPool(3, 10) // 3个协程，10个任务队列
	pool.Start()

	// 提交15个任务
	for i := 0; i < 15; i++ {
		//id := i
		pool.Submit(func() {
			time.Sleep(500 * time.Millisecond)
			//fmt.Printf("Task %d done by %d\n", id, <-getGoroutineID())
		})
	}

	time.Sleep(3 * time.Second)
	pool.Shutdown()
	fmt.Println("Pool gracefully stopped")
}

// 辅助函数：获取当前协程ID（仅限演示）
func getGoroutineID() int {
	var buf [64]byte
	n := runtime.Stack(buf[:], false)
	for i := n - 1; i >= 0; i-- {
		if buf[i] == '\n' {
			return int(buf[i-1]) - '0'
		}
	}
	return 0
}
